package cc.rengu.igas.bomp.core.service.trans;

import cc.rengu.igas.bomp.common.constant.TableNameConstant;
import cc.rengu.igas.bomp.common.dao.*;
import cc.rengu.igas.bomp.common.dao.impl.*;
import cc.rengu.igas.bomp.common.entity.BizTmp;
import cc.rengu.igas.bomp.common.entity.MchntAcctInfo;
import cc.rengu.igas.bomp.common.entity.MchntBaseInfo;
import cc.rengu.igas.bomp.common.entity.MchntSignInfo;
import cc.rengu.igas.bomp.common.enums.*;
import cc.rengu.igas.bomp.common.util.InitParamUtil;
import cc.rengu.igas.bomp.core.service.base.ManageService;
import cc.rengu.igas.bomp.facade.bean.*;
import cc.rengu.igas.bomp.facade.request.MchntBatchImportRequest;
import cc.rengu.igas.bomp.facade.response.MchntBatchImportResponse;
import cc.rengu.oltp.service.common.constant.AppConfigConstant;
import cc.rengu.oltp.service.common.constant.AppParamConstant;
import cc.rengu.oltp.service.model.BizException;
import cc.rengu.oltp.service.model.BizResponse;
import cc.rengu.oltp.utility.util.*;
import com.alibaba.fastjson.JSONObject;
import org.springframework.util.CollectionUtils;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.regex.Pattern;
import java.util.stream.Stream;

/**
 * @author zhangxuran
 * @version 1.0
 * @date 2020/04/21
 */
public class MchntBatchImportService extends ManageService {
    @Override
    protected Object bizBeforeCust() throws Exception {
        MchntBatchImportRequest mchntBatchImportRequest = new MchntBatchImportRequest();
        ConvertUtil.convertOutput(mchntBatchImportRequest);
        return mchntBatchImportRequest;
    }

    @Override
    protected BizResponse bizProcessCust(Object request) throws Exception {
        MchntBatchImportRequest mchntBatchImportRequest = (MchntBatchImportRequest) request;
        /*获取请求参数：法人行号，用户标识及导入数据*/
        String instId = mchntBatchImportRequest.getHeader().getInstId();
        /*获取用户信息*/
        String userId = mchntBatchImportRequest.getUserId();
        List<ImportMchntInfoBean> importMchntBaseInfoList = mchntBatchImportRequest.getMchntInfoList();
        if (StringUtil.isEmptyOrNull(userId) || StringUtil.isEmptyOrNull(instId)) {
            rglog.error("间联商户导入必填性校验失败");
            throw new BizException(RespCodeEnum.MSG_VALID_CHECK_ERROR.getRespCode(), RespCodeEnum.MSG_VALID_CHECK_ERROR.getRespDesc());
        }
        /*导入数据错误信息列表*/
        int successCount = 0;
        int errorCount = 0;
        List<ImportErrorInfoBean> importErrorInfoList = new ArrayList<>();
        for (ImportMchntInfoBean ImportMchntInfoBean : importMchntBaseInfoList) {
            StringBuilder errorInfo = new StringBuilder();
            ImportErrorInfoBean importErrorInfoBean = new ImportErrorInfoBean();
            importErrorInfoBean.setRecordSeq(ImportMchntInfoBean.getRecordSeq());
            /*获取商户基本信息*/
            MchntBaseInfoBean mchntBaseInfo = ImportMchntInfoBean.getMchntBaseInfo();
            /*获取商户连续人信息*/
            MchntContactsInfoBean mchntContactsInfo = ImportMchntInfoBean.getMchntContactsInfo();
            /*获取营业执照信息*/
            BusinessLicenceInfoBean businessLicenceInfo = ImportMchntInfoBean.getBusinessLicenceInfo();
            /*商户法人信息*/
            MchntArtifInfoBean mchntArtifInfo = ImportMchntInfoBean.getMchntArtifInfo();
            /*获取结算账户信息*/
            List<SettleAcctInfoBean> settleAcctInfoList = ImportMchntInfoBean.getSettleAcctInfoList();
            /*获取4位长度序列*/
            //生成商户号 3位法人行号 + yyMM + 4位行业类型 + 4位序号
            BompSequenceMapper bompSequenceMapper = new BompSequenceMapperImpl();
            //4位序号
            String mchntNoSuffix = bompSequenceMapper.getNextMchntNoSeq();
            String mchntNo = instId + DateUtil.formatDate(new Date(), "yyMM")
                    + mchntBaseInfo.getIndustryType() + mchntNoSuffix;
            /*1-商户基本信息和联系人信息基本校验（基本信息和联系人信息保存在商户基本信息表）*/
            String mchntBaseInfoError = checkMchntBaseInfo(mchntBaseInfo, mchntContactsInfo);
            /*2-商户营业执照信息和法人信息基本校验（营业执照信息和法人信息保存在签约信息表）*/
            String mchntSignInfoError = checkMchntSignInfo(businessLicenceInfo, mchntArtifInfo);
            /*3-结算账户信息基本校验*/
            String settleAcctInfoError = checkSettleAcctInfo(settleAcctInfoList);
            /*错误信息不为空时拼接错误信息*/
            if (!StringUtil.isEmptyOrNull(mchntBaseInfoError) || !StringUtil.isEmptyOrNull(mchntSignInfoError) || !StringUtil.isEmptyOrNull(settleAcctInfoError)) {
                errorInfo.append(mchntBaseInfoError).append(mchntSignInfoError).append(settleAcctInfoError);
                importErrorInfoBean.setErrorInfo(errorInfo.substring(0, errorInfo.length() - 1));
                importErrorInfoList.add(importErrorInfoBean);
                errorCount++;
                continue;
            }
            /*数据拼装入库操作*/
            /*临时表数据操作列表*/
            List<BizTmp> importBizTmpList = new ArrayList<>();
            /*1-复制商户基本信息*/
            MchntBaseInfo mchntBaseInfoEntity = new MchntBaseInfo();
            /*获取商户基本信息非业务主键*/
            String mchntBaseInfoId = RandomUtil.getUUID();
            BeanUtil.beanCopy(mchntBaseInfo, mchntBaseInfoEntity);
            BeanUtil.nullValueCopy(mchntContactsInfo, mchntBaseInfoEntity);
            /*法人行赋值*/
            mchntBaseInfoEntity.setInstId(instId);
            /*商户号赋值*/
            mchntBaseInfoEntity.setMchntNo(mchntNo);
            /*拓展渠道赋值*/
            mchntBaseInfoEntity.setMchntExpandChannel("MCMP");
            /*非业务主键赋值*/
            mchntBaseInfoEntity.setId(mchntBaseInfoId);
            /*商户状态默认赋值非正式*/
            mchntBaseInfoEntity.setMchntStatus(MchntStatusEnum.UNNORMAL.getStatus());
            /*审核状态默认赋值待提交审核*/
            mchntBaseInfoEntity.setAuditStatus(AuditStatusEnum.BE_AUDIT.getAuditStatus());
            /*创建人赋值*/
            mchntBaseInfoEntity.setOprId(userId);
            /*商户创建时间赋值*/
            mchntBaseInfoEntity.setCreateTime(DateUtil.getCurrentDateTime("yyyy-MM-dd HH:mm:ss.SSS"));
            /*商户入驻时间赋值*/
            mchntBaseInfoEntity.setMchntExpandTime(DateUtil.getCurrentDateTime("yyyy-MM-dd HH:mm:ss.SSS"));
            /*小额免费默认赋值*/
            mchntBaseInfoEntity.setNoPasswordFlag("N");
            /*是否支持信用卡默认赋值*/
            mchntBaseInfoEntity.setSupportCreditFlag("Y");

            /*商户基本信息临时表信息赋值*/
            BizTmp mchntBaseInfoTmp = new BizTmp();
            /*商户表赋值*/
            mchntBaseInfoTmp.setRealId(mchntBaseInfoId);
            /*法人行赋值*/
            mchntBaseInfoTmp.setInstId(instId);
            /*管理机构编码赋值*/
            mchntBaseInfoTmp.setManageInstId(mchntBaseInfo.getSignInstId());
            /*商户号赋值*/
            mchntBaseInfoTmp.setMchntNo(mchntNo);
            /*商户名赋值*/
            mchntBaseInfoTmp.setMchntName(mchntBaseInfo.getMchntName());
            mchntBaseInfoTmp.setOprTableEname(TableNameConstant.T_B_MCHNT_BASE_INFO);
            /*数据状态非正式*/
            mchntBaseInfoTmp.setBizStatus(BizTmpStatusEnum.NO_NORMAL.getType());
            /*操作类型赋值“新增”*/
            mchntBaseInfoTmp.setBizOpr("I");
            /*审核状态赋值*/
            mchntBaseInfoTmp.setAuditStatus(AuditStatusEnum.BE_AUDIT.getAuditStatus());
            /*是否明细记录标识赋值*/
            mchntBaseInfoTmp.setDetailFlag("N");
            /*商户基本信息业务数据拆分*/
            String mchntBaseInfoJsonString = JSONObject.toJSONString(mchntBaseInfoEntity);
            InitParamUtil.initBizTempData(mchntBaseInfoTmp, mchntBaseInfoJsonString);
            importBizTmpList.add(mchntBaseInfoTmp);

            /*2-复制商户签约信息*/
            MchntSignInfo mchntSignInfoEntity = new MchntSignInfo();
            BeanUtil.beanCopy(businessLicenceInfo, mchntSignInfoEntity);
            BeanUtil.nullValueCopy(mchntArtifInfo, mchntSignInfoEntity);
            /*法人行赋值*/
            mchntSignInfoEntity.setInstId(instId);
            /*商户号赋值*/
            mchntSignInfoEntity.setMchntNo(mchntNo);
            /*记录状态默认赋值非正式*/
            mchntSignInfoEntity.setRecordStatus("N");
            /*审核状态赋值*/
            mchntSignInfoEntity.setAuditStatus(AuditStatusEnum.BE_AUDIT.getAuditStatus());
            /*创建人赋值*/
            mchntSignInfoEntity.setOprId(userId);
            /*商户创建时间赋值*/
            mchntSignInfoEntity.setCreateTime(DateUtil.getCurrentDateTime("yyyy-MM-dd HH:mm:ss.SSS"));
            /*商户签约信息非业务主键*/
            String mchntSignInfoId = RandomUtil.getUUID();
            mchntSignInfoEntity.setId(mchntSignInfoId);

            /*签约信息临时表信息赋值*/
            BizTmp mchntSignInfoTmp = new BizTmp();
            /*临时表签约信息非业务主键赋值*/
            mchntSignInfoTmp.setRealId(mchntSignInfoId);
            /*法人行赋值*/
            mchntSignInfoTmp.setInstId(instId);
            /*管理机构编码赋值*/
            mchntSignInfoTmp.setManageInstId(mchntBaseInfo.getSignInstId());
            /*商户号赋值*/
            mchntSignInfoTmp.setMchntNo(mchntNo);
            /*商户名赋值*/
            mchntSignInfoTmp.setMchntName(mchntBaseInfo.getMchntName());
            mchntSignInfoTmp.setOprTableEname(TableNameConstant.T_B_MCHNT_SIGN_INFO);
            /*数据状态非正式*/
            mchntSignInfoTmp.setBizStatus(BizTmpStatusEnum.NO_NORMAL.getType());
            /*操作类型赋值“新增”*/
            mchntSignInfoTmp.setBizOpr("I");
            /*审核状态赋值*/
            mchntSignInfoTmp.setAuditStatus(AuditStatusEnum.BE_AUDIT.getAuditStatus());
            /*是否明细记录标识赋值*/
            mchntSignInfoTmp.setDetailFlag("Y");
            mchntSignInfoTmp.setMasterKey(mchntBaseInfoTmp.getRealId());
            /*商户签约信息业务数据拆分*/
            String mchntSignInfoJsonString = JSONObject.toJSONString(mchntSignInfoEntity);
            InitParamUtil.initBizTempData(mchntSignInfoTmp, mchntSignInfoJsonString);
            importBizTmpList.add(mchntSignInfoTmp);

            /*3-复制结算账户信息*/
            List<MchntAcctInfo> mchntAcctInfoList = new ArrayList<>();
            String mchntAcctInfoIId;
            String mchntAcctInfoJsonString;
            for (SettleAcctInfoBean settleAcctInfoBean : settleAcctInfoList) {
                MchntAcctInfo mchntAcctInfo = new MchntAcctInfo();
                BeanUtil.beanCopy(settleAcctInfoBean, mchntAcctInfo);
                /*法人行赋值*/
                mchntAcctInfo.setInstId(instId);
                /*商户号赋值*/
                mchntAcctInfo.setMchntNo(mchntNo);
                /*开户行信息赋值*/
                mchntAcctInfo.setAcctOpenBankName(settleAcctInfoBean.getSettleAcctBankName());
                mchntAcctInfo.setAcctOpenBankNo(settleAcctInfoBean.getSettleAcctBankNo());
                mchntAcctInfo.setAcctOpenArea(settleAcctInfoBean.getSettleAcctBankArea());
                mchntAcctInfo.setAcctOpenProvince(settleAcctInfoBean.getSettleAcctBankProvince());
                mchntAcctInfo.setAcctOpenCity(settleAcctInfoBean.getSettleAcctBankCity());
                /*记录状态赋值*/
                mchntAcctInfo.setRecordStatus("N");
                /*账户签约标志*/
                mchntAcctInfo.setAcctSignFlag("N");
                /*审核状态赋值*/
                mchntAcctInfo.setAuditStatus(AuditStatusEnum.BE_AUDIT.getAuditStatus());
                /*创建人赋值*/
                mchntAcctInfo.setOprId(userId);
                /*商户创建时间赋值*/
                mchntAcctInfo.setCreateTime(DateUtil.getCurrentDateTime("yyyy-MM-dd HH:mm:ss.SSS"));
                /*非业务主键赋值*/
                mchntAcctInfoIId = RandomUtil.getUUID();
                mchntAcctInfo.setId(mchntAcctInfoIId);

                /*结算信息临时表赋值*/
                BizTmp mchntAcctInfoTmp = new BizTmp();
                /*临时表签约信息非业务主键赋值*/
                mchntAcctInfoTmp.setRealId(mchntAcctInfoIId);
                /*法人行赋值*/
                mchntAcctInfoTmp.setInstId(instId);
                /*管理机构编码赋值*/
                mchntAcctInfoTmp.setManageInstId(mchntBaseInfo.getSignInstId());
                /*商户号赋值*/
                mchntAcctInfoTmp.setMchntNo(mchntNo);
                /*商户名赋值*/
                mchntAcctInfoTmp.setMchntName(mchntBaseInfo.getMchntName());
                mchntAcctInfoTmp.setOprTableEname(TableNameConstant.T_B_MCHNT_ACCT_INFO);
                /*数据状态非正式*/
                mchntAcctInfoTmp.setBizStatus(BizTmpStatusEnum.NO_NORMAL.getType());
                /*操作类型赋值“新增”*/
                mchntAcctInfoTmp.setBizOpr("I");
                /*审核状态赋值*/
                mchntAcctInfoTmp.setAuditStatus(AuditStatusEnum.BE_AUDIT.getAuditStatus());
                /*是否明细记录标识赋值*/
                mchntAcctInfoTmp.setDetailFlag("Y");
                mchntAcctInfoTmp.setMasterKey(mchntBaseInfoTmp.getRealId());
                /*商户结算账户信息业务数据拆分*/
                mchntAcctInfoJsonString = JSONObject.toJSONString(mchntAcctInfo);
                InitParamUtil.initBizTempData(mchntAcctInfoTmp, mchntAcctInfoJsonString);
                /*签约信息数据和临时签约信息整合*/
                mchntAcctInfoList.add(mchntAcctInfo);
                importBizTmpList.add(mchntAcctInfoTmp);
            }
            /*导入数据入库操作*/
            String dbErrorInfo = insertImportMchntInfo(mchntBaseInfoEntity, mchntSignInfoEntity, mchntAcctInfoList, importBizTmpList);
            if (!StringUtil.isEmptyOrNull(dbErrorInfo)) {
                errorInfo.append(dbErrorInfo);
                /*错误信息拼接*/
                importErrorInfoBean.setErrorInfo(errorInfo.substring(0, errorInfo.length() - 1));
                importErrorInfoList.add(importErrorInfoBean);
                /*错误数据数量增加*/
                errorCount++;
                continue;
            }
            if (errorInfo.length() == 0) {
                successCount++;
            }

        }
        /*组装报文信息*/
        MchntBatchImportResponse mchntBatchImportResponse = new MchntBatchImportResponse();
        /*导入成功数据数量赋值*/
        mchntBatchImportResponse.setSuccessTotal(String.valueOf(successCount));
        /*导入失败数据数量赋值*/
        mchntBatchImportResponse.setErrorTotal(String.valueOf(errorCount));
        /*导入失败原因信息列表*/
        mchntBatchImportResponse.setImportErrorInfoList(importErrorInfoList);
        /* 按照接口转换基础产品信息并响应给请求方 */
        BizResponse<MchntBatchImportResponse> bizResponse = new BizResponse<>();
        bizResponse.setRspSysId(AppParamConstant.SYS_ID);
        bizResponse.setRespCode(RespCodeEnum.TRANS_SUCCESS.getRespCode());
        bizResponse.setRespDesc(RespCodeEnum.TRANS_SUCCESS.getRespDesc());
        bizResponse.setResult(mchntBatchImportResponse);
        return bizResponse;
    }

    /**
     * 间联商户导入数据入库操作
     *
     * @params mchntBaseInfoEntity 商户基本信息数据
     * @params mchntSignInfoEntity 商户签约信息数据
     * @params mchntAcctInfoList  商户结算列表信息数据
     * @params importBizTmpList  临时业务列表信息数据
     * return 错误信息
     */
    private String insertImportMchntInfo(MchntBaseInfo mchntBaseInfoEntity, MchntSignInfo mchntSignInfoEntity, List<MchntAcctInfo> mchntAcctInfoList, List<BizTmp> importBizTmpList) throws Exception {
        StringBuilder dbErrorInfo = new StringBuilder();
        /* 开启数据库事务 */
        String dbPoolName = XmlConfigUtil.getXmlConfigCacheKeyValue(AppConfigConstant.DATABASE_CONF_NODE, AppConfigConstant.MCMP_POOL_NAME);
        XmlTreeUtil xmlTreeUtil = new XmlTreeUtil();
        String corporation = xmlTreeUtil.getXmlTreeStringValue(AppParamConstant.CORPORATION);
        if (null != corporation && !corporation.isEmpty()) {
            String dbPoolCashNode = corporation.trim() + AppParamConstant.DATABASE_CONF_NODE;
            dbPoolName = XmlConfigUtil.getXmlConfigCacheKeyValue(dbPoolCashNode, AppConfigConstant.MCMP_POOL_NAME);
        }
        DbsUtil dbsUtil = new DbsUtil(dbPoolName);
        dbsUtil.dbsBeginTransaction();
        /*执行结果初始化*/
        int dbResult;
        boolean dbFlag = true;
        /*1-商户基本信息入库*/
        MchntBaseInfoMapper mchntBaseInfoMapper = new MchntBaseInfoMapperImpl();
        dbResult = mchntBaseInfoMapper.insertMchntBaseInfo(mchntBaseInfoEntity);
        if (0 != dbResult) {
            dbFlag = false;
            rglog.error("新增商户基本信息表失败！id:{},mchnt:{},instId:{}", mchntBaseInfoEntity.getId(), mchntBaseInfoEntity.getMchntNo(), mchntBaseInfoEntity.getInstId());
            dbErrorInfo.append("商户基本信息入库失败,");
        }
        /*2-商户签约信息入库*/
        MchntSignInfoMapper mchntSignInfoMapper = new MchntSignInfoMapperImpl();
        dbResult = mchntSignInfoMapper.insertMchntSignInfo(mchntSignInfoEntity);
        if (0 != dbResult) {
            dbFlag = false;
            rglog.error("新增商户签约信息表失败！id:{},mchnt:{},instId:{}", mchntSignInfoEntity.getId(), mchntSignInfoEntity.getMchntNo(), mchntSignInfoEntity.getInstId());
            dbErrorInfo.append("商户签约信息入库失败,");
        }
        /*3结算账户信息入库*/
        MchntAcctInfoMapper mchntAcctInfoMapper = new MchntAcctInfoMapperImpl();
        for (MchntAcctInfo mchntAcctInfo : mchntAcctInfoList) {
            dbResult = mchntAcctInfoMapper.insertMchntAcctInfo(mchntAcctInfo);
            if (0 != dbResult) {
                dbFlag = false;
                rglog.error("新增商户结算信息表失败！id:{},mchnt:{},instId:{},acctNo:{}", mchntAcctInfo.getId(), mchntAcctInfo.getMchntNo(), mchntAcctInfo.getInstId(), mchntAcctInfo.getSettleAcctNo());
                dbErrorInfo.append("结算账户为").append(mchntAcctInfo.getSettleAcctNo()).append("的商户结算信息失败信息入库失败,");
            }
        }
        /*4 临时表数据入库*/
        BizTmpMapper bizTmpMapper = new BizTmpMapperImpl();
        for (BizTmp bizTmp : importBizTmpList) {
            dbResult = bizTmpMapper.insertBizTmp(bizTmp);
            if (0 != dbResult) {
                dbFlag = false;
                rglog.error("新增商户临时信息表失败！mchnt:{},instId:{},acctNo:{}", bizTmp.getMchntNo(), bizTmp.getInstId());
                dbErrorInfo.append("新增临时表").append(bizTmp.getOprTableEname()).append("的表信息失败信息入库失败,");
            }
        }
        dbsUtil.dbsEndTransaction(dbFlag);
        return dbErrorInfo.toString();
    }

    /**
     * 商户基本信息和联系人信息交易
     *
     * @param mchntBaseInfo     商户基本信息
     * @param mchntContactsInfo 商户联系人信息
     **/
    private String checkMchntBaseInfo(MchntBaseInfoBean mchntBaseInfo, MchntContactsInfoBean mchntContactsInfo) {
        StringBuilder baseInfoError = new StringBuilder();
        /*1-商户基本信息校验*/
        if (null != mchntBaseInfo) {
            /*商户类型校验*/
            String mchntType = mchntBaseInfo.getMchntType();
            if (StringUtil.isEmptyOrNull(mchntType)) {
                /*非空校验*/
                baseInfoError.append("商户类型为空,");
            } else {
                if (StringUtil.isEmptyOrNull(MchntTypeEnum.getMchntDescBymchntType(mchntType))) {
                    /*枚举校验*/
                    baseInfoError.append("间联商户类型不存在,");
                }
            }
            /*商户名称校验*/
            String mchntName = mchntBaseInfo.getMchntName();
            if (StringUtil.isEmptyOrNull(mchntName)) {
                /*非空校验*/
                baseInfoError.append("商户名称为空,");
            }
            /*商户简称校验*/
            String mchntSimpleName = mchntBaseInfo.getMchntSimpleName();
            if (StringUtil.isEmptyOrNull(mchntSimpleName)) {
                /*非空校验*/
                baseInfoError.append("商户简称为空,");
            }
            /*营业地址校验*/
            String mchntBizAddr = mchntBaseInfo.getMchntBizAddr();
            if (StringUtil.isEmptyOrNull(mchntBizAddr)) {
                /*非空校验*/
                baseInfoError.append("营业地址为空,");
            }
            /*商户性质校验*/
            String mchntNature = mchntBaseInfo.getMchntNature();
            if (StringUtil.isEmptyOrNull(mchntNature)) {
                /*非空校验*/
                baseInfoError.append("商户性质为空,");
            }
            /*签约机构校验*/
            String signInstId = mchntBaseInfo.getSignInstId();
            if (StringUtil.isEmptyOrNull(signInstId)) {
                /*非空校验*/
                baseInfoError.append("签约机构为空,");
            }
            /*商户等级校验*/
            String mchntLevel = mchntBaseInfo.getMchntLevel();
            if (StringUtil.isEmptyOrNull(mchntLevel)) {
                /*非空校验*/
                baseInfoError.append("商户等级为空,");
            }
            /*经营范围校验*/
            String managementScope = mchntBaseInfo.getManagementScope();
            if (StringUtil.isEmptyOrNull(managementScope)) {
                /*非空校验*/
                baseInfoError.append("经营范围为空,");
            }
            /*行业类别校验*/
            String industryType = mchntBaseInfo.getIndustryType();
            if (StringUtil.isEmptyOrNull(industryType)) {
                /*非空校验*/
                baseInfoError.append("行业类别为空,");
            }
            /*商户拓展方式*/
            String mchntExpandType = mchntBaseInfo.getMchntExpandType();
            if (StringUtil.isEmptyOrNull(mchntExpandType)) {
                /*非空校验*/
                baseInfoError.append("商户拓展方式为空,");
            } else {
                if (Stream.of("01", "02", "03").noneMatch(s -> s.equals(mchntExpandType))) {
                    /*枚举校验*/
                    baseInfoError.append("商户拓展方式不存在,");
                }
            }
            /*自主开展营销标识校验*/
            String marketFlag = mchntBaseInfo.getMarketFlag();
            if (StringUtil.isEmptyOrNull(marketFlag)) {
                /*非空校验*/
                baseInfoError.append("自主开展营销标识为空,");
            } else {
                if (!(AppParamConstant.YES.equals(marketFlag) || AppParamConstant.NO.equals(marketFlag))) {
                    /*枚举校验*/
                    baseInfoError.append("自主开展营销标识不存在,");
                }
            }
            /*发送短信标识*/
            String smsFlag = mchntBaseInfo.getSmsFlag();
            if (StringUtil.isEmptyOrNull(smsFlag)) {
                /*非空校验*/
                baseInfoError.append("发送短信标识为空,");
            } else {
                if (!(AppParamConstant.YES.equals(smsFlag) || AppParamConstant.NO.equals(smsFlag))) {
                    /*枚举校验*/
                    baseInfoError.append("发送短信标识不存在,");
                }
            }
            /*邮箱发送对账单标识*/
            String reconMailFlag = mchntBaseInfo.getReconMailFlag();
            if (StringUtil.isEmptyOrNull(reconMailFlag)) {
                /*非空校验*/
                baseInfoError.append("邮箱发送对账单标识为空,");
            } else {
                if (!(AppParamConstant.YES.equals(reconMailFlag) || AppParamConstant.NO.equals(reconMailFlag))) {
                    /*枚举校验*/
                    baseInfoError.append("邮箱发送对账单标识不存在,");
                }
            }
            /*商户属性校验*/
            String mchntAttr = mchntBaseInfo.getMchntAttr();
            if (StringUtil.isEmptyOrNull(mchntAttr)) {
                /*非空校验*/
                baseInfoError.append("商户属性为空,");
            } else {
                if (StringUtil.isEmptyOrNull(MchntAttrEnum.attrDesc(mchntAttr))) {
                    /*枚举校验*/
                    baseInfoError.append("商户属性不存在,");
                }
            }
            /*网络域名校验*/
            String mchntNetworkDomain = mchntBaseInfo.getMchntNetworkDomain();
            if ((MchntAttrEnum.ALL_MCHNT.getMchntAttrCode().equals(mchntAttr) || MchntAttrEnum.ONLINE_MCHNT.getMchntAttrCode().equals(mchntAttr)) && StringUtil.isEmptyOrNull(mchntNetworkDomain)) {
                /*非空校验*/
                baseInfoError.append("线上商户网络域名为空,");
            }
            /*ICP备案号校验*/
            String icpRecordNo = mchntBaseInfo.getIcpRecordNo();
            if ((MchntAttrEnum.ALL_MCHNT.getMchntAttrCode().equals(mchntAttr) || MchntAttrEnum.ONLINE_MCHNT.getMchntAttrCode().equals(mchntAttr)) && StringUtil.isEmptyOrNull(icpRecordNo)) {
                /*非空校验*/
                baseInfoError.append("线上商户ICP备案号为空,");
            }
            /*IP地址校验*/
            String ip = mchntBaseInfo.getIp();
            if ((MchntAttrEnum.ALL_MCHNT.getMchntAttrCode().equals(mchntAttr) || MchntAttrEnum.ONLINE_MCHNT.getMchntAttrCode().equals(mchntAttr)) && StringUtil.isEmptyOrNull(ip)) {
                /*非空校验*/
                baseInfoError.append("线上商户IP地址为空,");
            }
            /*是否开通本行卡实时清算校验*/
            String realSettleFlag = mchntBaseInfo.getRealSettleFlag();
            if (StringUtil.isEmptyOrNull(realSettleFlag)) {
                /*非空校验*/
                baseInfoError.append("是否开通本行卡实时清算为空,");
            } else {
                if (!(AppParamConstant.YES.equals(realSettleFlag) || AppParamConstant.NO.equals(realSettleFlag))) {
                    /*枚举校验*/
                    baseInfoError.append("是否开通本行卡实时清算不存在,");
                }
            }
            /*商户结算模式校验*/
            String mchntSettleMode = mchntBaseInfo.getMchntSettleMode();
            if (StringUtil.isEmptyOrNull(mchntSettleMode)) {
                /*非空校验*/
                baseInfoError.append("商户结算模式为空,");
            } else {
                if (!("00".equals(mchntSettleMode) || "01".equals(mchntSettleMode))) {
                    /*枚举校验*/
                    baseInfoError.append("商户结算模式不存在,");
                }
            }
            /*商户延迟清算标志校验*/
            String mchntDelayFlag = mchntBaseInfo.getMchntDelayFlag();
            if (StringUtil.isEmptyOrNull(mchntDelayFlag)) {
                /*非空校验*/
                baseInfoError.append("商户延迟清算标志为空,");
            } else {
                if (!(AppParamConstant.YES.equals(mchntDelayFlag) || AppParamConstant.NO.equals(mchntDelayFlag))) {
                    /*枚举校验*/
                    baseInfoError.append("商户延迟清算标志不存在,");
                }
            }
            /*开通提现标志*/
            String cashWithdrawalFlag = mchntBaseInfo.getCashWithdrawalFlag();
            if (StringUtil.isEmptyOrNull(cashWithdrawalFlag)) {
                /*非空校验*/
                baseInfoError.append("开通提现标志为空,");
            } else {
                if (!(AppParamConstant.YES.equals(cashWithdrawalFlag) || AppParamConstant.NO.equals(cashWithdrawalFlag))) {
                    /*枚举校验*/
                    baseInfoError.append("开通提现标志不存在,");
                }
            }
            /*拓展经理工号*/
            String managerId = mchntBaseInfo.getManagerId();
            if (StringUtil.isEmptyOrNull(managerId)) {
                /*非空校验*/
                baseInfoError.append("拓展经理工号为空,");
            }
            /*拓展经理姓名*/
            String managerName = mchntBaseInfo.getManagerName();
            if (StringUtil.isEmptyOrNull(managerName)) {
                /*非空校验*/
                baseInfoError.append("拓展经理姓名为空,");
            }
        } else {
            baseInfoError.append("商户基本信息为空,");
        }
        /*2-检验联系人信息*/
        if (null != mchntContactsInfo) {
            /*联系人证件类型校验*/
            String contactCertType = mchntContactsInfo.getContactCertType();
            if (!StringUtil.isEmptyOrNull(contactCertType) && StringUtil.isEmptyOrNull(ArtifCertTypeEbnum.getDescByCode(contactCertType))) {
                /*枚举校验*/
                baseInfoError.append("联系人证件类型不存在,");
            }
        }
        return baseInfoError.toString();
    }

    /**
     * 校验营业执照信息和法人信息
     *
     * @param businessLicenceInfo 营业执照信息
     * @param mchntArtifInfo      法人信息
     **/
    private String checkMchntSignInfo(BusinessLicenceInfoBean businessLicenceInfo, MchntArtifInfoBean mchntArtifInfo) {
        StringBuilder signInfoError = new StringBuilder();
        if (null != businessLicenceInfo) {
            /*营业执照注册类型校验*/
            String licenceType = businessLicenceInfo.getLicenceType();
            if (StringUtil.isEmptyOrNull(licenceType)) {
                /*非空判断*/
                signInfoError.append("营业执照注册类型为空,");
            } else {
                if (StringUtil.isEmptyOrNull(LicenseTypeEnum.getLicenceDescBylicenseType(licenceType))) {
                    /*枚举判断*/
                    signInfoError.append("营业执照注册类型不存在,");
                }
            }
            /*企业注册类型校验*/
            String enterRegisterType = businessLicenceInfo.getEnterRegisterType();
            if (StringUtil.isEmptyOrNull(enterRegisterType)) {
                /*非空判断*/
                signInfoError.append("企业注册类型为空,");
            } else {
                if (StringUtil.isEmptyOrNull(RegisterTypeEnum.getDescByType(enterRegisterType))) {
                    /*枚举判断*/
                    signInfoError.append("企业注册类型不存在,");
                }
            }
            /*营业执照生效日期校验*/
            String licenceEffectiveDate = businessLicenceInfo.getLicenceEffectiveDate();
            /*营业执照类型是生效日期不为空*/
            if (LicenseTypeEnum.BUSINESS_LICENSE.getLicenseType().equals(licenceType) && StringUtil.isEmptyOrNull(licenceEffectiveDate)) {
                signInfoError.append("证件类型为营业执照，营业执照证件生效日期为空,");
            }
            /*营业执照失效日期校验*/
            String licenceExpiryDate = businessLicenceInfo.getLicenceExpiryDate();
            /*营业执照类型是失效日期不为空*/
            if (LicenseTypeEnum.BUSINESS_LICENSE.getLicenseType().equals(licenceType) && StringUtil.isEmptyOrNull(licenceExpiryDate)) {
                signInfoError.append("证件类型为营业执照，营业执照证件失效日期为空,");
            }
        } else {
            signInfoError.append("签约信息为空,");
        }
        if (null != mchntArtifInfo) {
            /*法人姓名校验*/
            String artifName = mchntArtifInfo.getArtifName();
            if (StringUtil.isEmptyOrNull(artifName)) {
                signInfoError.append("法人姓名为空,");
            }
            /*法人证件类型校验*/
            String artifCertType = mchntArtifInfo.getArtifCertType();
            if (StringUtil.isEmptyOrNull(artifCertType)) {
                signInfoError.append("法人证件类型为空,");
            } else {
                if (StringUtil.isEmptyOrNull(ArtifCertTypeEbnum.getDescByCode(artifCertType))) {
                    signInfoError.append("法人证件类型不存在,");
                }
            }
            /*法人证件号码校验*/
            String artifCertNo = mchntArtifInfo.getArtifCertNo();
            if (StringUtil.isEmptyOrNull(artifCertNo)) {
                signInfoError.append("法人证件号码为空,");
            }
            /*法人证件生效日期校验*/
            String certEffectiveDate = mchntArtifInfo.getCertEffectiveDate();
            if (StringUtil.isEmptyOrNull(certEffectiveDate)) {
                signInfoError.append("法人证件生效日期为空,");
            }
            /*证件失效日期校验*/
            String certExpiryDate = mchntArtifInfo.getCertExpiryDate();
            if (StringUtil.isEmptyOrNull(certExpiryDate)) {
                signInfoError.append("法人证件失效日期为空,");
            }
            /*法人手机号校验*/
            Pattern mobilePattern = Pattern.compile("^1[3456789][0-9]{9}$");
            String artifMobile = mchntArtifInfo.getArtifMobile();
            if (StringUtil.isEmptyOrNull(artifMobile)) {
                signInfoError.append("法人手机号为空,");
            } else {
                if (!mobilePattern.matcher(artifMobile).find()) {
                    signInfoError.append("法人手机号格式错误,");
                }
            }
        } else {
            signInfoError.append("法人信息为空,");
        }
        return signInfoError.toString();
    }

    /**
     * 校验结算账户信息
     *
     * @param settleAcctInfoList 结算账户信息列表
     **/
    private String checkSettleAcctInfo(List<SettleAcctInfoBean> settleAcctInfoList) {
        StringBuilder settleAccountError = new StringBuilder();
        if (CollectionUtils.isEmpty(settleAcctInfoList)) {
            settleAccountError.append("结算账户信息为空,");
        } else {
            for (SettleAcctInfoBean settleAcctInfoBean : settleAcctInfoList) {
                /*校验资金类型*/
                String fundType = settleAcctInfoBean.getFundType();
                if (StringUtil.isEmptyOrNull(fundType)) {
                    /*非空判断*/
                    settleAccountError.append("资金类型为空,");
                } else {
                    if (StringUtil.isEmptyOrNull(FundTypeEnum.getFundDescByfundCode(fundType))) {
                        /*枚举值校验*/
                        settleAccountError.append("资金类型不存在,");
                    }
                }
                /*基础产品代码校验*/
                String baseProdCode = settleAcctInfoBean.getBaseProdCode();
                /*非空校验*/
                if (StringUtil.isEmptyOrNull(baseProdCode)) {
                    settleAccountError.append("基础产品代码为空,");
                } else {
                    if (StringUtil.isEmptyOrNull(BaseProdEnum.getProdDescByproCode(baseProdCode))) {
                        /*枚举值校验*/
                        settleAccountError.append("基础产品代码不存在,");
                    }
                }
                /*结算方式校验*/
                String settleType = settleAcctInfoBean.getSettleType();
                if (StringUtil.isEmptyOrNull(settleType)) {
                    /*非空校验*/
                    settleAccountError.append("结算方式为空,");
                } else {
                    if (StringUtil.isEmptyOrNull(SettleTypeEnum.getDescBycode(settleType))) {
                        /*枚举值校验*/
                        settleAccountError.append("结算方式不存在,");
                    }
                }
                /*结算周期校验*/
                int settleCycle = settleAcctInfoBean.getSettleCycle();
                /*结算周期不能超过一个季度最大天数*/
                if (settleCycle < 0 || settleCycle > 92) {
                    settleAccountError.append("结算周期错误,");
                }
                /*结算账户类型校验*/
                String settleAcctType = settleAcctInfoBean.getSettleAcctType();
                if (StringUtil.isEmptyOrNull(settleAcctType)) {
                    /*非空校验*/
                    settleAccountError.append("结算账户类型为空,");
                } else {
                    if (StringUtil.isEmptyOrNull(SettleAcctTypeEnum.getAcctDescByacctType(settleAcctType))) {
                        /*枚举交易*/
                        settleAccountError.append("结算账户类型不存在,");
                    }
                }
                /*结算账户账户校验*/
                String settleAcctNo = settleAcctInfoBean.getSettleAcctNo();
                /*非空校验*/
                if (StringUtil.isEmptyOrNull(settleAcctNo)) {
                    settleAccountError.append("结算账户账号为空,");
                }
                /*账户格式校验*/
                Pattern acctNoPattern = Pattern.compile("^[0-9a-zA-Z\\-_]+$");
                if (!acctNoPattern.matcher(settleAcctNo).find()) {
                    settleAccountError.append("结算账户账号格式错误（只允许数字，字母和-及_）,");
                }
                /*结算账户户名校验*/
                String settleAcctName = settleAcctInfoBean.getSettleAcctName();
                /*非空校验*/
                if (StringUtil.isEmptyOrNull(settleAcctName)) {
                    settleAccountError.append("结算账户名称为空,");
                }
                /*结算账户开户行行号校验*/
                String settleAcctBankNo = settleAcctInfoBean.getSettleAcctBankNo();
                if (StringUtil.isEmptyOrNull(settleAcctBankNo)) {
                    settleAccountError.append("结算账户开户行行号为空,");
                }
            }
        }
        return settleAccountError.toString();
    }

    @Override
    protected void bizAfterCust(Object response) throws Exception {
        BizResponse bizResponse = (BizResponse) response;
        MchntBatchImportResponse mchntBatchImportResponse = (MchntBatchImportResponse) bizResponse.getResult();
        ConvertUtil.convertInput(mchntBatchImportResponse);
    }
}